// 通用工具函数

/**
 * 格式化日期时间
 * @param {Date|string|null|undefined} date - 日期对象或日期字符串
 * @param {string} format - 格式化模板，默认为 'YYYY-MM-DD HH:mm:ss'
 * @returns {string} 格式化后的日期字符串或提示信息
 */
export function formatDate(date, format = 'YYYY-MM-DD HH:mm:ss') {
  // 处理空值
  if (!date) return '暂无日期';
  
  // 确保日期格式正确处理，特别是MySQL返回的日期字符串
  let d;
  if (typeof date === 'string') {
    // 处理MySQL日期格式，确保正确解析
    d = new Date(date.replace(/T/g, ' ').replace(/\..+/, ''));
  } else {
    d = new Date(date);
  }
  
  // 检查日期是否有效
  if (isNaN(d.getTime())) {
    console.error('无效的日期:', date);
    return '日期无效';
  }
  
  const year = d.getFullYear();
  const month = String(d.getMonth() + 1).padStart(2, '0');
  const day = String(d.getDate()).padStart(2, '0');
  const hours = String(d.getHours()).padStart(2, '0');
  const minutes = String(d.getMinutes()).padStart(2, '0');
  const seconds = String(d.getSeconds()).padStart(2, '0');
  
  return format
    .replace('YYYY', year)
    .replace('MM', month)
    .replace('DD', day)
    .replace('HH', hours)
    .replace('mm', minutes)
    .replace('ss', seconds);
}

/**
 * 获取当前用户信息
 * @returns {Object|null} 用户信息对象
 */
export function getCurrentUser() {
  const userInfo = localStorage.getItem('userInfo');
  return userInfo ? JSON.parse(userInfo) : null;
}

/**
 * 保存用户信息到本地存储
 * @param {Object} userInfo - 用户信息
 */
export function saveUserInfo(userInfo) {
  localStorage.setItem('userInfo', JSON.stringify(userInfo));
}

/**
 * 清除本地存储的用户信息
 */
export function clearUserInfo() {
  localStorage.removeItem('userInfo');
  localStorage.removeItem('token');
}

/**
 * 验证表单字段
 * @param {Object} rules - 验证规则
 * @param {Object} formData - 表单数据
 * @returns {Object} 验证结果 { valid: boolean, errors: Object }
 */
export function validateForm(rules, formData) {
  const errors = {};
  let isValid = true;
  
  Object.keys(rules).forEach(field => {
    const value = formData[field];
    const fieldRules = rules[field];
    
    // 必填验证
    if (fieldRules.required && (!value || value.trim() === '')) {
      errors[field] = fieldRules.message || '此字段为必填项';
      isValid = false;
    }
    
    // 长度验证
    if (value && fieldRules.minLength && value.length < fieldRules.minLength) {
      errors[field] = fieldRules.message || `长度不能少于${fieldRules.minLength}个字符`;
      isValid = false;
    }
    
    if (value && fieldRules.maxLength && value.length > fieldRules.maxLength) {
      errors[field] = fieldRules.message || `长度不能超过${fieldRules.maxLength}个字符`;
      isValid = false;
    }
    
    // 正则验证
    if (value && fieldRules.pattern && !fieldRules.pattern.test(value)) {
      errors[field] = fieldRules.message || '格式不正确';
      isValid = false;
    }
  });
  
  return { valid: isValid, errors };
}

/**
 * 显示提示信息
 * @param {string} message - 提示内容
 * @param {string|number} type - 提示类型：'success'-成功，'error'-错误，'warning'-警告，'info'-信息，或对应的数字类型
 */
export function showMessage(message, type = 0) {
  if (window.layer) {
    // 定义自定义消息内容，包含emoji图标
    let customMessage = '';
    let iconType = 0; // 默认图标类型
    
    // 处理字符串类型的type参数
    if (typeof type === 'string') {
      switch (type.toLowerCase()) {
        case 'success':
          // 成功消息，使用绿色笑脸emoji
          customMessage = '😊 ' + message;
          break;
        case 'error':
          // 错误消息，使用红色悲伤脸emoji
          customMessage = '😢 ' + message;
          break;
        case 'warning':
          // 警告消息，使用黄色警告emoji
          customMessage = '⚠️ ' + message;
          break;
        case 'info':
          // 信息消息，使用蓝色信息emoji
          customMessage = 'ℹ️ ' + message;
          break;
        default:
          customMessage = message;
      }
    } else {
      // 处理数字类型的type参数
      switch (type) {
        case 1: // 成功
          customMessage = '😊 ' + message;
          break;
        case 2: // 错误
          customMessage = '😢 ' + message;
          break;
        case 3: // 警告
          customMessage = '⚠️ ' + message;
          break;
        case 4: // 疑问
          customMessage = '❓ ' + message;
          break;
        default: // 默认
          customMessage = message;
      }
    }
    
    // 创建一个新的层，不使用layui默认的图标系统，直接在消息文本中使用emoji
    layer.msg(customMessage, {
      time: 2000, // 消息显示时间
      skin: 'custom-message-style', // 自定义样式类名
      icon: -1, // 完全禁用默认图标
      shift: 0 // 默认动画效果
    });
    
    // 添加自定义CSS样式
    setTimeout(() => {
      // 移除默认的图标元素
      const msgBoxes = document.querySelectorAll('.layui-layer.msg');
      msgBoxes.forEach(box => {
        const iconElem = box.querySelector('.layui-layer-ico');
        if (iconElem) {
          // 隐藏默认图标，保留emoji在消息文本中
          iconElem.style.display = 'none';
        }
        
        // 根据消息类型添加相应的样式
        const messageText = box.textContent;
        if (messageText.includes('😊')) {
          // 成功消息样式
          box.style.backgroundColor = '#f6ffed';
          box.style.borderColor = '#b7eb8f';
        } else if (messageText.includes('😢')) {
          // 错误消息样式
          box.style.backgroundColor = '#fff2f0';
          box.style.borderColor = '#ffccc7';
        } else if (messageText.includes('⚠️')) {
          // 警告消息样式
          box.style.backgroundColor = '#fffbe6';
          box.style.borderColor = '#ffe58f';
        } else if (messageText.includes('ℹ️')) {
          // 信息消息样式
          box.style.backgroundColor = '#edf2fc';
          box.style.borderColor = '#adc6ff';
        }
        
        // 调整emoji大小和样式
        box.style.fontSize = '16px';
        box.style.padding = '10px 15px';
      });
    }, 10);
  } else {
    console.log(message);
  }
}

/**
 * 处理图片粘贴事件
 * @param {ClipboardEvent} event - 粘贴事件对象
 * @returns {Promise<File|null>} 粘贴的图片文件
 */
export function handleImagePaste(event) {
  return new Promise((resolve) => {
    const items = (event.clipboardData || event.originalEvent?.clipboardData).items;
    
    for (let item of items) {
      if (item.kind === 'file' && item.type.indexOf('image/') !== -1) {
        const file = item.getAsFile();
        resolve(file);
        return;
      }
    }
    
    resolve(null);
  });
}

/**
 * 将图片文件转换为Base64
 * @param {File} file - 图片文件
 * @returns {Promise<string>} Base64字符串
 */
export function fileToBase64(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onload = () => resolve(reader.result);
    reader.onerror = () => reject(new Error('文件读取失败'));
    reader.readAsDataURL(file);
  });
}

/**
 * 检查文件类型是否为图片
 * @param {File} file - 文件对象
 * @returns {boolean} 是否为图片
 */
export function isImageFile(file) {
  const imageTypes = ['image/jpeg', 'image/png', 'image/gif', 'image/bmp', 'image/webp'];
  return imageTypes.includes(file.type);
}

/**
 * 获取文件大小的可读格式
 * @param {number} bytes - 文件大小（字节）
 * @returns {string} 可读的文件大小
 */
export function formatFileSize(bytes) {
  if (bytes === 0) return '0 Bytes';
  
  const k = 1024;
  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
  const i = Math.floor(Math.log(bytes) / Math.log(k));
  
  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
}